home *** CD-ROM | disk | FTP | other *** search
/ Aminet 2 / Aminet AMIGA CDROM (1994)(Walnut Creek)[Feb 1994][W.O. 44790-1].iso / Aminet / mus / play / tracker_3_19.lzh / tracker / st_read.c < prev    next >
C/C++ Source or Header  |  1993-11-17  |  10KB  |  426 lines
  1. /* st_read.c */
  2.  
  3. /* $Id: st_read.c,v 3.10 1993/11/17 15:31:16 espie Exp espie $
  4.  * $Log: st_read.c,v $
  5.  * Revision 3.10  1993/11/17  15:31:16  espie
  6.  * *** empty log message ***
  7.  *
  8.  * Revision 3.9  1993/11/11  20:00:03  espie
  9.  * Amiga support.
  10.  *
  11.  * Revision 3.7  1993/07/17  12:00:30  espie
  12.  * Added other commands (numerous).
  13.  *
  14.  * Revision 3.2  1992/11/22  17:20:01  espie
  15.  * Checks for finetune ?
  16.  *
  17.  * Revision 3.1  1992/11/19  20:44:47  espie
  18.  * Protracker commands.
  19.  *
  20.  * Revision 3.0  1992/11/18  16:08:05  espie
  21.  * New release.
  22.  *
  23.  * Revision 2.16  1992/11/17  17:06:25  espie
  24.  * fix_xxx for better speed.
  25.  * Added some sample information in the dump.
  26.  * Added transpose feature.
  27.  * Feature fix: length 1 sample should be empty.
  28.  * Corrected repeat length problems concerning badly formed files,
  29.  * added signature checking for new tracker files.
  30.  * Corrected small problem with repeat being too short.
  31.  * Coded error types. More amiga specific stuff.
  32.  *
  33.  * Revision 1.17  1991/11/17  16:30:48  espie
  34.  * Rationnalized error recovery.
  35.  * There was a bug: you could try to deallocate
  36.  * stuff in no-noland. Also, strings never got
  37.  * to be freed.
  38.  * Centralized error control to error_song.
  39.  * Added a new test on length, aborts most modules now.
  40.  * Maybe should say it as well.
  41.  * Added checkpoints for early return if file too short.
  42.  * Added memory recovery and error control.
  43.  * Suppressed ! warning for bad note.
  44.  * Added note support.
  45.  * Corrected length and rep_length/rep_offset
  46.  * which are given in words and should be converted to
  47.  * bytes.
  48.  */
  49.  
  50. #ifdef AMIGA
  51. #include <stdlib.h>
  52. #else
  53. #include <malloc.h>
  54. #endif
  55. #include <stdio.h>
  56. #include <string.h>
  57. #include <ctype.h>
  58. #include <assert.h>
  59.  
  60. #include "defs.h"
  61. #include "extern.h"
  62. #include "song.h"
  63. #include "channel.h"
  64.  
  65. LOCAL char *id = "$Id: st_read.c,v 3.10 1993/11/17 15:31:16 espie Exp espie $";
  66.  
  67. /***
  68.  *
  69.  *    Low level st-file access routines 
  70.  *
  71.  ***/
  72.  
  73. /* c = checkgetc(f):
  74.  * gets a character from file f.
  75.  * Aborts program if file f is finished
  76.  */
  77. LOCAL int checkgetc(f)
  78. FILE *f;
  79.     {
  80.     int c;
  81.  
  82.     if ((c = fgetc(f)) == EOF)
  83.         error = FILE_TOO_SHORT;
  84.     return c;
  85.     }
  86.  
  87. #define MAX_LEN 50
  88. /* s = getstring(f, len):
  89.  * gets a soundtracker string from file f.
  90.  * I.e, it is a fixed length string terminated
  91.  * by a 0 if too short. Length should be
  92.  * smaller than MAX_LEN.
  93.  */
  94. LOCAL char *getstring(f, len)
  95. FILE *f;
  96. int len;
  97.     {
  98.     static char s[MAX_LEN];
  99.     char *new;
  100.     int i;
  101.         
  102.     assert(len < MAX_LEN);
  103.     for (i = 0; i < len; i++)
  104.         s[MIN(i, MAX_LEN - 1)] = checkgetc(f);
  105.     s[MIN(len, MAX_LEN - 1)] = '\0';
  106.     new = malloc(strlen(s)+1);
  107.  
  108.     return strcpy(new, s);
  109.     }
  110.  
  111. /* byteskip(f, len)
  112.  * same as fseek, xcpt it works on stdin
  113.  */
  114. LOCAL void byteskip(f, len)
  115. FILE *f;
  116. int len;
  117.     {
  118.     int i;
  119.  
  120.     for (i = 0; i < len; i++)
  121.         checkgetc(f);
  122.     }
  123.  
  124. /* v = getushort(f)
  125.  * reads an unsigned short from f
  126.  */
  127. LOCAL int getushort(f)
  128. FILE *f;
  129.     {
  130.     int i;
  131.  
  132.         /* order dependent !!! */
  133.     i = checkgetc(f) << 8;
  134.     return i | checkgetc(f);
  135.     }
  136.  
  137.  
  138. /* fill_sample_info(info, f):
  139.      fill sample info with the information at current position of
  140.      file f. Allocate memory for storing the sample, also.
  141.     fill_sample_info is guaranteed to give you an accurate snapshot
  142.     of what sample should be like. In particular, length, rp_length,
  143.     start, rp_start, fix_length, fix_rp_length will have the values
  144.     you can expect if part of the sample is missing.
  145.  */
  146. LOCAL void fill_sample_info(info, f)
  147. struct sample_info *info;
  148. FILE *f;
  149.     {
  150.     info->name = getstring(f, SAMPLENAME_MAXLENGTH);
  151.     info->length = getushort(f);
  152.     info->finetune = checkgetc(f);
  153.     if (info->finetune > 15)
  154.         info->finetune = 0;
  155.     info->volume = checkgetc(f);
  156.     info->volume = MIN(info->volume, MAX_VOLUME);
  157.     info->rp_offset = getushort(f);
  158.     info->rp_length = getushort(f);
  159.  
  160.     /* the next check is for old modules for which
  161.      * the sample data types are a bit confused, so
  162.      * that what we were expecting to be #words is #bytes.
  163.      */
  164.         /* not sure I understand the -1 myself, though it's
  165.          * necessary to play kawai-k1 correctly 
  166.          */
  167.     if (info->rp_length + info->rp_offset - 1 > info->length)
  168.         info->rp_offset /= 2;
  169.     
  170.     if (info->rp_length + info->rp_offset > info->length)
  171.         info->rp_length = info->length - info->rp_offset;
  172.  
  173.     info->length *= 2;
  174.     info->rp_offset *= 2;
  175.     info->rp_length *= 2;
  176.         /* in all logic, a 2-sized sample could exist,
  177.          * but this is not the case, and even so, some
  178.          * trackers output empty instruments as being 2-sized.
  179.          */
  180.     if (info->length <= 2)
  181.         {
  182.         info->start = NULL;
  183.         info->length = 0;
  184.         }
  185.     else
  186.         {
  187.         info->start = (SAMPLE *)alloc_sample(info->length);
  188.  
  189.         if (info->rp_length > 2)
  190.             info->rp_start = info->start + info->rp_offset;
  191.         else
  192.             {
  193.             info->rp_start = NULL;
  194.             info->rp_length = 0;
  195.             }
  196.         }
  197.  
  198.     if (info->length > MAX_SAMPLE_LENGTH)
  199.         error = CORRUPT_FILE;
  200.     info->fix_length = int_to_fix(info->length);
  201.     info->fix_rp_length = int_to_fix(info->rp_length);
  202.     }
  203.  
  204. LOCAL void fill_song_info(info, f)
  205. struct song_info *info;
  206. FILE *f;
  207.     {
  208.     int i;
  209.     int p;
  210.  
  211.     info->length = checkgetc(f);
  212.     checkgetc(f);
  213.     info->maxpat = -1;
  214.     for (i = 0; i < NUMBER_PATTERNS; i++)
  215.         {
  216.         p = checkgetc(f);
  217.         if (p >= NUMBER_PATTERNS)
  218.             p = 0;
  219.         if (p > info->maxpat)
  220.             info->maxpat = p;
  221.         info->patnumber[i] = p;
  222.         }
  223.     info->maxpat++;
  224.     if (info->maxpat == 0 || info->length == 0)
  225.         error = CORRUPT_FILE;
  226.     }
  227.  
  228. LOCAL void fill_event(e, f)
  229. struct event *e;
  230. FILE *f;
  231.     {
  232.     int a, b, c, d;
  233.  
  234.     a = checkgetc(f);
  235.     b = checkgetc(f);
  236.     c = checkgetc(f);
  237.     d = checkgetc(f);
  238.     e->sample_number = (a & 0x10) | (c >> 4);
  239.     e->effect = c & 0xf;
  240.     e->parameters = d;
  241.     if (e->effect == EFF_EXTENDED)
  242.         {
  243.         e->effect = EXT_BASE + HI(e->parameters);
  244.         e->parameters = LOW(e->parameters);
  245.         }
  246.     if (e->effect == 0)
  247.         e->effect = e->parameters ? EFF_ARPEGGIO : EFF_NONE;
  248.     if (e->effect == EFF_SKIP)
  249.         e->parameters = HI(e->parameters) * 10 + LOW(e->parameters);
  250.     e->pitch = ( (a & 15) << 8 ) | b;
  251.     e->note = find_note(e->pitch);
  252.     }
  253.  
  254. LOCAL void fill_pattern(pattern, f)
  255. struct block *pattern;
  256. FILE *f;
  257.     {
  258.     int i, j;
  259.  
  260.     for (i = 0; i < BLOCK_LENGTH; i++)
  261.         for (j = 0; j < NUMBER_TRACKS; j++)
  262.             fill_event(&(pattern->e[j][i]), f);
  263.     }
  264.  
  265.  
  266. LOCAL void read_sample(info, f)
  267. struct sample_info *info;
  268. FILE *f;
  269.     {
  270.  
  271.     if (info->start)
  272.         {
  273.         fread(info->start, 1, info->length, f);
  274.         }
  275.     }
  276.  
  277.  
  278.  
  279.  
  280. /***
  281.  *
  282.  *  new_song: allocates a new structure for a song.
  283.  *  clears each and every field as appropriate.
  284.  *
  285.  ***/
  286. LOCAL struct song *new_song()
  287.     {
  288.     struct song *new;
  289.     int i;
  290.  
  291.     new = (struct song *)malloc(sizeof(struct song));
  292.     new->title = NULL;
  293.     new->info.length = 0;
  294.     new->info.maxpat = -1;
  295.     new->info.transpose = 0;
  296.     new->info.pblocks = NULL;
  297.     for (i = 0; i < NUMBER_SAMPLES; i++)
  298.         {
  299.         new->samples[i].finetune = 0;
  300.         new->samples[i].name = NULL;
  301.         new->samples[i].length = 0;
  302.         new->samples[i].start = NULL;
  303.         new->samples[i].rp_start = NULL;
  304.         new->samples[i].fix_length = 0;
  305.         new->samples[i].fix_rp_length = 0;
  306.         }
  307.     return new;
  308.     }
  309.  
  310. /* release_song(song): gives back all memory 
  311.  * occupied by song. Assume that each structure
  312.  * has been correctly allocated by a call to the
  313.  * corresponding new_XXX function.
  314.  */
  315. void release_song(song)
  316. struct song *song;
  317.     {
  318.     int i;
  319.  
  320.     for (i = 0; i < NUMBER_SAMPLES; i++)
  321.         {
  322.         if (song->samples[i].start)
  323.             free_sample(song->samples[i].start);
  324.         if (song->samples[i].name)
  325.             free(song->samples[i].name);
  326.         }
  327.     if (song->info.pblocks)
  328.         free(song->info.pblocks);
  329.     if (song->title)
  330.         free(song->title);
  331.     free(song);
  332.     }
  333.  
  334. /* error_song(song): what we should return
  335.  * if there was an error. Actually, is mostly
  336.  * useful for its side effects.
  337.  */
  338. LOCAL struct song *error_song(song)
  339. struct song *song;
  340.     {
  341.     release_song(song);
  342.     return NULL;
  343.     }
  344.  
  345. /* bad_sig(f): read the signature on file f
  346.  * and returns TRUE if it is not a known sig.
  347.  */
  348. LOCAL BOOL bad_sig(f)
  349. FILE *f;
  350.     {
  351.     char a, b, c, d;
  352.  
  353.     a = checkgetc(f);
  354.     b = checkgetc(f);
  355.     c = checkgetc(f);
  356.     d = checkgetc(f);
  357.     if (a == 'M' && b == '.' && c == 'K' && d == '.')
  358.         return FALSE;
  359.     if (a == 'M' && b == '&' && c == 'K' && d == '!')
  360.         return FALSE;
  361.     if (a == 'F' && b == 'L' && c == 'T' && d == '4')
  362.         return FALSE;
  363.     return TRUE;
  364.     }
  365.  
  366. /* s = read_song(f, type): tries to read a song s
  367.  * of type NEW/OLD in file f. Might fail, i.e.,
  368.  * returns NULL if file is not a mod file of the
  369.  * correct type.
  370.  */
  371. struct song *read_song(f, type)
  372. FILE *f;
  373. int type;
  374.     {
  375.     struct song *song;
  376.     int i;
  377.     int ninstr;
  378.  
  379.     error = NONE;
  380.     if (type == NEW || type == NEW_NO_CHECK)
  381.         ninstr = 31;
  382.     else
  383.         ninstr = 15;
  384.  
  385.     song = new_song();
  386.     song->title = getstring(f, TITLE_MAXLENGTH);
  387.     if (error != NONE)
  388.         return error_song(song);
  389.  
  390.     for (i = 1; i <= ninstr; i++)
  391.         {
  392.         fill_sample_info(&song->samples[i], f);
  393.         if (error != NONE)
  394.             return error_song(song);
  395.         }
  396.  
  397.     fill_song_info(&song->info, f);
  398.  
  399.     if (error != NONE)
  400.         return error_song(song);
  401.  
  402.     if (type == NEW && bad_sig(f))
  403.         return error_song(song);
  404.  
  405.     if (type == NEW_NO_CHECK)
  406.         byteskip(f, 4);
  407.         
  408.  
  409.     song->info.pblocks = (struct block *)
  410.         malloc(sizeof(struct block) * song->info.maxpat);
  411.     for (i = 0; i < song->info.maxpat; i++)
  412.         {
  413.         fill_pattern(song->info.pblocks + i, f);
  414.         if (error != NONE)
  415.             return error_song(song);
  416.         }
  417.  
  418.     for (i = 1; i <= ninstr; i++)
  419.         read_sample(&song->samples[i], f);
  420.     
  421.     if (error != NONE)
  422.         return error_song(song);
  423.     return song;
  424.     }
  425.  
  426.